home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / kevoSource / context.h < prev    next >
Text File  |  1993-05-12  |  3KB  |  107 lines
  1. /* Kevo -- a prototype-based object-oriented language */
  2. /* (c) Antero Taivalsaari 1991-1993                   */
  3. /* Some parts (c) Antero Taivalsaari 1986-1988           */
  4. /* context.h: Name space (context) structures and internals */
  5.  
  6. /*------------------------------------------------------------------------*/
  7. /* Context structures */
  8.  
  9. /* 
  10.     Contexts are name spaces (vocabularies) that refer to the properties 
  11.     of objects. Context is a mapping from a set of names (PAIRs) to OBJECTs.
  12.     An individual pair is a mapping from a name to an object. 
  13.  
  14.     Context is implemented as a bidirectional linked list of pairs. To one 
  15.     direction the linked list is hashed (multi-linked) to speed up the name 
  16.     lookup. To the other direction there is only a single link that tells the 
  17.     original definition order of the properties.
  18. */
  19.  
  20. /*    Number of threads in the multi-linked (hashed) dictionary structure.
  21.     This can be any positive integer (default = 8).
  22.     The more threads we have, the faster the lookup
  23.     (but more memory is also required). */
  24. #define    CONTEXTSIZE    8
  25.  
  26. typedef struct contextStruct     CONTEXT;
  27. typedef struct pairStruct         PAIR;
  28.  
  29. struct contextStruct {
  30.     PAIR*     lastPair[CONTEXTSIZE];    /* Array of pointers to latest pairs */    
  31.     PAIR*     firstPair;                /* Pointer to first pair */
  32.     PAIR*     latestPair;            /* Pointer to latest definition */
  33.     CONTEXT* nextContext;             /* Next defined context in the system */
  34.     LIST*     cloneFamily;            /* Contains all the OOP objects of this kind */
  35.     LIST*     parentFamilies;        /* Contains "parent" clone families */
  36.     LIST*     childFamilies;            /* Contains "child" clone families */
  37. };
  38.  
  39. /* 
  40.    Keep 'ofa' as the first field of 'pairStruct'. 
  41.    This is important for efficiency. 
  42. */
  43.  
  44. struct pairStruct {
  45.     OBJECT*  ofa;    /* Target of the identifier (object field address) */
  46.     char*      nfa;    /* Identifier name (name field address) */
  47.     PAIR*     lfa;      /* Pointer to the previous pair (link field address) */
  48.     PAIR*     sfa;    /* Pointer to next pair (successor field address) */
  49.     CONTEXT* cfa;    /* Pointer to the context to which this pair belongs */
  50.     int          ffa;    /* Flag field (flag field address) */
  51. };
  52.  
  53. /* The following operations are "inlined" for speed */
  54.  
  55. #define        hash(id)            ((int)(*id) % CONTEXTSIZE)
  56. #define        getContext(object)    ((CONTEXT*)(object)->mfa->pfa)
  57.  
  58.  
  59. CONTEXT*     createContext();
  60. CONTEXT*     copyContext();
  61. void        deleteContext();
  62.  
  63. int            comparePairs();
  64. int            compareContexts();
  65. int            compareContextResemblance();
  66.  
  67. int            isContextObject();
  68. /* CONTEXT*    getContext(); */
  69.  
  70. PAIR*         addPair();
  71. void         unlinkPair();
  72. void        renamePair();
  73. void         hide();
  74. PAIR*        copyPair();
  75. PAIR*        addBeforePair();
  76.  
  77. PAIR*        findPairInThis();
  78. PAIR*        findPairBackward();
  79.  
  80. PAIR*        findNameInThis();
  81. PAIR*        findNameBackward();
  82. PAIR*        findNameForward();
  83.  
  84. PAIR*        findTypeForward();
  85. PAIR*        findPrimName();
  86.  
  87.  
  88. /* Object-oriented operations */
  89.  
  90. PAIR*        selfLookUp();
  91. PAIR*        messageLookUp();
  92. PAIR*        respondsTo();
  93.  
  94. OBJECT**    getREFslot();
  95. int            getVARoffset();
  96. OBJECT**    getVARslot();
  97.  
  98. int            countAllPairs();
  99. int            countDataPairs();
  100. int            countOperPairs();
  101.  
  102. PAIR*        findAllAsIndexed();
  103. PAIR*        findDataAsIndexed();
  104. PAIR*        findOperAsIndexed();
  105.  
  106. void        checkIntegrity();
  107.